import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;



class SubTree {
    String pre;
    String post;
    public SubTree(String pre , String post) {
        this.pre = pre;
        this.post = post;
    }
}
public class demo {

//    有理数运算▲▲▲▲▲  主要注意括号添加
//实现对两个有理数的基本运算，包括加、减、乘、除。
//输入描述：
//每个输入文件只包含一个测试用例，测试用例会给出一行数据，格式为“a1/b1 a2/b2”
//
//分子分母的范围都在长整型的范围内，如果数字为负，则符号只会出现在分子的前面。分母一定是非零数。
//输出描述：
//针对每个测试用例，都输出四行，分别是这两个有理数的和、差、积和商，格式为“数1 操作符 数2 = 结果”。注
//意，所有的有理数都将遵循一个简单形式“k a/b”，其中k是整数部分，a/b是最简分数形式，如果该数为负数，则必
//须用括号包起来。如果除法中的除数为0，则输出“Inf”。结果中所有的整数都在long int的范围内。
//    输入
//      5/3 0/6
//    输出
//      1 2/3 + 0 = 1 2/3
//      1 2/3 - 0 = 1 2/3
//      1 2/3 * 0 = 0
//      1 2/3 / 0 = Inf



    // 优化   将分子 分母(化简)    a分子     b分母(不可能为0)
    public static void print(long a, long b) {
        // 先约分
        long x = gcd(a, b);
        a = a/x;
        b = b/x;
        // 如果分母小于0 将符号移至分子
        if (b < 0) {
            a = -a;
            b = -b;
        }
        // 判断 a和b的大小关系
        if (a < 0) {
            if (-a % b == 0) {
                System.out.print("(" + a/b +")");
            }else if (-a < b) {
                System.out.print("(" + a + "/" + b +")");
            }else {//-a>b
                //   (-a-((-a/b)*b))  括号记得加
                System.out.print("(" + a/b + " " + (-a+((a/b)*b)) + "/" + b +")");
            }
        }else {//a>=0
            if (a % b == 0) {
                System.out.print(a/b);
            }else if (a < b) {
                System.out.print(a + "/" + b);
            }else {// a>b
                System.out.print(a/b + " " + (a-((a/b)*b)) + "/" + b);
                //a-((a/b)*b)这里最外面要记得加括号 不然前面字符串+a 导致类型不对报错
            }
        }
    }
    // 求最大公约数
    public static long gcd(long a, long b) {
        if (a == 0) {
            return 1;
        }
        long r = a % b;
        while (r != 0) {
            a = b;
            b = r;
            r = a % b;
        }
        return b;
    }
    // 加
    public static void add(long a1, long b1, long a2, long b2) {
        print(a1, b1);
        System.out.print(" + ");
        print(a2, b2);
        System.out.print(" = ");
        print(a1*b2+a2*b1, b1*b2);
    }
    // 减
    public static void sub(long a1, long b1, long a2, long b2) {
        print(a1, b1);
        System.out.print(" - ");
        print(a2, b2);
        System.out.print(" = ");
        print(a1*b2-a2*b1, b1*b2);
    }
    // 乘
    public static void mul(long a1, long b1, long a2, long b2) {
        print(a1, b1);
        System.out.print(" * ");
        print(a2, b2);
        System.out.print(" = ");
        print(a1*a2, b1*b2);
    }
    // 除
    public static void div(long a1, long b1, long a2, long b2) {
        print(a1, b1);
        System.out.print(" / ");
        print(a2, b2);
        System.out.print(" = ");
        if (a2 == 0) {
            System.out.print("Inf");
        }else {
            // 因为分数相除 就是乘除数的倒数  这样如果a2是负数 我们要将符号移到分子(b2)上
            if (a2 < 0) {
                b2 = -b2;
                a2 = -a2;
            }
            print(a1*b2, b1*a2);
        }

    }
    public static void main1(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            String str = scanner.nextLine();
            // 先将字符串通过空格分隔开
            String[] st = str.split(" ");
            // 分开后再通过 / 将分子和分母也一起分开
            String[] s1 = st[0].split("/");
            String[] s2 = st[1].split("/");
            // 然后我们得到分母和分子 (这里我们要将字符串类型转换成long类型 方便后续计算 通过Long.parseLong()方法  )
            Long a1 = Long.parseLong(s1[0]);
            Long b1 = Long.parseLong(s1[1]);
            Long a2 = Long.parseLong(s2[0]);
            Long b2 = Long.parseLong(s2[1]);
            // 进行计算
            add(a1,b1,a2,b2);
            System.out.println();// 记得打印换行(注意格式)
            sub(a1,b1,a2,b2);
            System.out.println();
            mul(a1,b1,a2,b2);
            System.out.println();
            div(a1,b1,a2,b2);
            System.out.println();
        }
    }





//    前序和后序▲▲▲▲▲
//我们都很熟悉二叉树的前序、中序和后序遍历。在数据结构类中，通常会遇到给定中序和后序的情况下求前序的问
//题，或是给定前序和中序求后序的问题。但一般情况下，当给定树的前序和后序时，并不能确定树的中序遍历。
//它们都拥有着相同的前序和后序。其实这种情况不仅仅限于二叉树，M叉树也是一样。
//      输入描述：
//输入是由多个测试用例组成。每个用例只有一行，格式为m s1 s2，表示树是m叉树，s1是前序遍历，s2是后序遍
//历。所有字符串将由小写字母字符组成。对于所有的输入实例，1<=m<=20，s1和s2的长度将介于1和26之间（含
//1和26）。如果s1的长度是k（当然，s2也是这么长），那使用的就是字母表的前K个字母。输入一行0表示终止输
//入。
//      输出描述：
//对于每个测试用例都要输出一行，表示中序遍历满足该条件的数的个数。输出的范围不会超过int的范围，对于每条
//用例，都保证至少有一棵树满足要求。

//    输入
//2 abc cba
//2 abc bca
//10 abc bca
//13 abejkcfghid jkebfghicda
//    输出
//4
//1
//45
//207352860

//  思路
//因为是m叉树，所以可以得到当前根节点的子树有多少组合方式，再
//去到每一颗子树，如此递归直到找到所有叶子结点
//比如    abejkcfghid     jkebfghicda
//找到先序序列的第一个节点和后序序列的最后一个节点，这个节点就是当前的根节点
//当前的根→a bejk  cfghi  d         jkeb  fghic  d a
//           ↑     ↑     ↑           ↑     ↑    ↑
//找到3个区间，说明这一层有三颗子树 然后我们通过递归 继续找字树的子树



    // 保存分离出来子树的前序和后序结果
    // 放在类(demo36)的外面
//     class SubTree {
//        String pre;
//        String post;
//        public SubTree(String pre , String post) {
//            this.pre = pre;
//            this.post = post;
//        }
//    }



    // 通过前序遍历和后序遍历 计算有多少种树的可能
    public static long CalcPossible(int m, String preOrder, String postOrder) {
        // 该题需要递归来寻找子树的子树
        // 如果树是空的 或者只有一个根节点 我们返回1
        if (preOrder.isEmpty() || preOrder.length()==1) {
            return 1;
        }

        // 将树的子树分离出来 保存在链表中  求链表长度是size方法
        List<SubTree> subTree = splitTree(preOrder, postOrder);
        long count = CalSubTree(m, subTree.size());

        // 然后对子树再进行查找
        for (SubTree e:subTree) {
            count *= CalcPossible(m, e.pre, e.post);
        }
        return count;
    }



    // 分离出的子树的前序和后序遍历结果保存到链表中 返回
    public static List<SubTree> splitTree(String pre, String post) {
        // 我们从前序遍历的第二个字符开始在后序遍历中找
        // 因为第一个字符是 整个树的根 所以我们要找子树的根 就要从前序遍历第二个字符开始在后序遍历中找
        List<SubTree> subTrees = new ArrayList<>();
        int preFirst = 1;
//        a bejk cfghid     jkeb fghicd a
        while (preFirst < pre.length()) {
            // 找出现的 第一个子树的根节点
            char preRoot = pre.charAt(preFirst);
            // 在后序遍历中找 他的位置
            int postRootIdx = post.indexOf(preRoot);

            // 子树的前序和后序遍历结果 保存到链表中
            String preResult = pre.substring(preFirst, postRootIdx+2);
            String postResult = post.substring(preFirst-1, postRootIdx+1);
            subTrees.add(new SubTree(preResult, postResult));

            // 更新preFirst  更新到pre的第二个子树的下标
            preFirst = postRootIdx + 2;
        }
        return subTrees;
    }

    // 通过前序和后序遍历 计算有多少种树  (排列组合计算C(m)(types))
    // 分子molecule       分母denominator
    public static long CalSubTree(int m, int types) {
        // 减少计算次数
        types = Math.min(types, m-types);
        long mol = 1;
        long dem = 1;
        // 分子部分
        for (int i=m; i>m-types; i--) {
            mol *= i;
        }
        // 分母部分
        for (int i=1; i<=types; i++) {
            dem *= i;
        }
        return mol/dem;
    }
    //

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int m = scanner.nextInt();
            // 判断 如果m=0  树为0 就没必要继续算了
            if (m == 0) {
                break;
            }
            // 前序结果
            String preOrder = scanner.next();
            // 后序结果
            String poseOrder = scanner.next();
            long sum = CalcPossible(m, preOrder, poseOrder);
            System.out.println(sum);
        }
    }
}
